import { ElMessage } from 'element-plus'
import { removeToken } from './auth'
import router from '@/router'

/**
 * 全局错误处理类
 */
export class ErrorHandler {
  /**
   * 处理401未授权错误
   */
  static handle401Error(): void {
    console.log('全局错误处理器：检测到401错误，开始处理登出逻辑')
    
    // 防止重复处理401错误
    if (sessionStorage.getItem('handling_401_error') === 'true') {
      console.log('全局错误处理器：正在处理401错误，跳过重复处理')
      return
    }
    
    // 设置标记，防止重复处理
    sessionStorage.setItem('handling_401_error', 'true')
    
    // 清除所有本地存储
    removeToken()
    localStorage.removeItem('user_roles')
    localStorage.removeItem('userRole')
    localStorage.removeItem('userMenus')
    localStorage.removeItem('currentUsername')
    localStorage.removeItem('userInfo')
    
    // 获取当前路径
    const currentPath = window.location.pathname
    console.log('全局错误处理器：当前路径:', currentPath)
    
    // 如果当前不在登录页，强制跳转
    if (currentPath !== '/login') {
      // 检查是否已经在跳转中
      if (sessionStorage.getItem('redirecting_to_login') === 'true') {
        console.log('全局错误处理器：正在跳转登录页，跳过重复处理')
        return
      }
      
      // 设置跳转标记
      sessionStorage.setItem('redirecting_to_login', 'true')
      
      // 显示提示消息
      ElMessage({
        message: '登录已过期，请重新登录',
        type: 'warning',
        duration: 3000
      })
      
      // 使用window.location强制跳转，确保页面完全重新加载
      console.log('全局错误处理器：使用window.location跳转到登录页')
      window.location.href = '/login'
      
      // 清除跳转标记
      setTimeout(() => {
        sessionStorage.removeItem('redirecting_to_login')
      }, 1000)
    } else {
      // 如果当前已经在登录页，刷新页面确保状态正确
      console.log('全局错误处理器：当前已在登录页，刷新页面')
      window.location.reload()
    }
    
    // 清除401处理标记
    setTimeout(() => {
      sessionStorage.removeItem('handling_401_error')
    }, 2000)
  }

  /**
   * 处理网络错误
   */
  static handleNetworkError(error: any): void {
    console.error('全局错误处理器：网络错误:', error)
    
    let message = '网络连接失败'
    if (error.code === 'ECONNABORTED') {
      message = '请求超时，请检查网络连接'
    } else if (error.message.includes('Network Error')) {
      message = '网络连接异常，请检查网络设置'
    }
    
    ElMessage({
      message,
      type: 'error',
      duration: 5000
    })
  }

  /**
   * 处理服务器错误
   */
  static handleServerError(status: number, message?: string): void {
    console.error('全局错误处理器：服务器错误，状态码:', status)
    
    let errorMessage = message || '服务器内部错误'
    
    switch (status) {
      case 400:
        errorMessage = '请求参数错误'
        break
      case 403:
        errorMessage = '没有权限访问该资源'
        break
      case 404:
        errorMessage = '请求的资源不存在'
        break
      case 500:
        errorMessage = '服务器内部错误'
        break
      case 502:
        errorMessage = '网关错误'
        break
      case 503:
        errorMessage = '服务暂时不可用'
        break
      case 504:
        errorMessage = '网关超时'
        break
    }
    
    ElMessage({
      message: errorMessage,
      type: 'error',
      duration: 5000
    })
  }

  /**
   * 处理业务逻辑错误
   */
  static handleBusinessError(code: number, message: string): void {
    console.error('全局错误处理器：业务逻辑错误，错误码:', code, '错误信息:', message)
    
    // 特殊处理401错误
    if (code === 401) {
      this.handle401Error()
      return
    }
    
    ElMessage({
      message: message || '操作失败',
      type: 'error',
      duration: 5000
    })
  }

  /**
   * 通用错误处理
   */
  static handleError(error: any): void {
    console.error('全局错误处理器：通用错误:', error)
    
    // 如果是401错误，直接处理
    if (error.response?.status === 401 || error.code === 401) {
      this.handle401Error()
      return
    }
    
    // 如果是网络错误
    if (error.code === 'ECONNABORTED' || error.message?.includes('Network Error')) {
      this.handleNetworkError(error)
      return
    }
    
    // 如果是服务器错误
    if (error.response?.status) {
      this.handleServerError(error.response.status, error.response.data?.message)
      return
    }
    
    // 如果是业务逻辑错误
    if (error.code && error.message) {
      this.handleBusinessError(error.code, error.message)
      return
    }
    
    // 默认错误处理
    ElMessage({
      message: error.message || '未知错误',
      type: 'error',
      duration: 5000
    })
  }
}

/**
 * 设置全局错误处理器
 */
export function setupGlobalErrorHandler(): void {
  // 处理未捕获的Promise错误
  window.addEventListener('unhandledrejection', (event) => {
    console.error('全局错误处理器：未处理的Promise错误:', event.reason)
    
    // 检查是否是401错误
    if (event.reason?.response?.status === 401 || event.reason?.code === 401) {
      ErrorHandler.handle401Error()
    } else {
      ErrorHandler.handleError(event.reason)
    }
    event.preventDefault()
  })

  // 处理未捕获的JavaScript错误
  window.addEventListener('error', (event) => {
    console.error('全局错误处理器：未处理的JavaScript错误:', event.error)
    ErrorHandler.handleError(event.error)
    event.preventDefault()
  })
  
  // 监听网络状态变化
  window.addEventListener('online', () => {
    console.log('全局错误处理器：网络已连接')
  })
  
  window.addEventListener('offline', () => {
    console.log('全局错误处理器：网络已断开')
    ElMessage({
      message: '网络连接已断开，请检查网络设置',
      type: 'warning',
      duration: 5000
    })
  })
}

export default ErrorHandler
